/**
 * @addtogroup jtc_msg_808
 * jtc_msg_808_session_comp
     
 * @code
    本组件完成808会话接口的实现
        1.完成跟平台的鉴权和注册逻辑，注册信息通过事件方式跟应用程序匹配
        2.内部完成心跳维护工作
        3.检测通讯链路超时断开逻辑，超时时间应用可配置
        4.掉电不进行鉴权码的存储，需要应用存储
   
    以下为样例代码
    
    #include "jtc_msg_808/jtc_msg_808_session_comp.h"
    #include "jtc_msg_808/jtc_msg_808_mgr.h"
    #include "jtc_msg_808/jtc_msg_808_codec.h"
    #include "jtc_msg_808/jtc_msg_808.h"
    #include "ofc/ofc_string.h"
    #include "mfc/mf_serial_vir_bus_uart_comp.h"
    #include "jtc_msg_808/jtc_msg_808_session_comp.h"
    
    static TJtMsg808SessionComp g_msg_808_session_;
    static TJtMsg808Mgr g_msg_808_mgr_;
    static Byte g_session_recv_buf_[1100];
    static Byte g_session_encode_buf_[2100];
    static Byte g_session_decode_buf_[2100];
    static const char kTestTrmModel[] = "TXJ-BR4-HQ12";
    
    // 连接id和端口
    static const char kHostObosParam[] = "192.168.116.97:2045";
    
    // 获取厂家id号
    static int GetTestManufactureId(char *buf, int len)
    {
        int result;
    
        if (buf == NULL)
        {
            result = 5;
        }
        else if (len < 5)
        {
            result = kJtMsg808SessionCompResultIllegal;
        }
        else
        {
            memcpy(buf, "70211", 5);
            result = 5;
        }
    
        return result;
    }
    
    // 获取终端型号
    static int GetTestTrmModel(char *buf, int len)
    {
        int result;
    
        if (buf == NULL)
        {
            result = strlen(kTestTrmModel);
        }
        else if (len < strlen(kTestTrmModel))
        {
            result = kJtMsg808SessionCompResultIllegal;
        }
        else
        {
            result = strlen(kTestTrmModel);
            memcpy(buf, kTestTrmModel, result);
        }
    
        return result;
    }
    
    // 获取终端ID号
    static int GetTestTrmId(char *buf, int len)
    {
        int result;
    
        if (buf == NULL)
        {
            result = 7;
        }
        else if (len < 7)
        {
            result = kJtMsg808SessionCompResultIllegal;
        }
        else
        {
            result = 7;
            memcpy(buf, "1234567", result);
        }
    
        return result;
    }
    
    // 获取车牌号
    static int GetTestVehicleNo(char *buf, int len)
    {
        int result;
    
        if (buf == NULL)
        {
            result = 8;
        }
        else if (len < 8)
        {
            result = kJtMsg808SessionCompResultIllegal;
        }
        else
        {
            result = 8;
            memcpy(buf, "AAA12345", result);
        }
    
        return result;
    }
    
    // 获取VIN码
    static int GetTestVehicleVin(char *buf, int len)
    {
        int result;
    
        if (buf == NULL)
        {
            result = 17;
        }
        else if (len < 17)
        {
            result = kJtMsg808SessionCompResultIllegal;
        }
        else
        {
            result = 17;
            memcpy(buf, "VIN12345678912345", result);
        }
    
        return result;
    }
    
    // 获取SIM卡的IMEI号
    static int GetTestSimImei(char *buf, int len)
    {
        int result;
    
        if (buf == NULL)
        {
            result = 10;
        }
        else if (len < 10)
        {
            result = kJtMsg808SessionCompResultIllegal;
        }
        else
        {
            result = 10;
            memcpy(buf, "0123456789", result);
        }
    
        return result;
    }
    
    // 获取终端软件版本号
    static int GetTestTrmSoftwareVer(char *buf, int len)
    {
        int result;
    
        if (buf == NULL)
        {
            result = 4;
        }
        else if (len < 4)
        {
            result = kJtMsg808SessionCompResultIllegal;
        }
        else
        {
            result = 4;
            memcpy(buf, "V1.0", result);
        }
    
        return result;
    }
    
    // 获取ip个数
    static Int32 GetHostCount(void)
    {
        return 1;
    }
    
    // 获取ip参数
    static Int32 GetHostParam(char *param1, long param2)
    {
        Int32 result = 0;
    
        if (param1 == NULL)
        {
            result = strlen(kHostObosParam);
        }
        else
        {
            Int32 buf_len = param2 & 0xFFFF;
            Int32 obos_param_len = strlen(kHostObosParam);
    
            // 这里高16bit不取，只连接一个obos通道，低16bit为param1的长度,后期需要改为从配置获取
            if (buf_len < obos_param_len)
                result = -1;
            else
            {
                memcpy((void *)param1, kHostObosParam, obos_param_len);
                result = obos_param_len;
            }
        }
    
        return result;
    }
    
    // 获取会话参数属性
    static int TJtMsg808SessionCompAttrEvent(void *sender, int attr_type, void *param1, long param2)
    {
        int result = kJtMsg808SessionCompResultFail;
        
        switch (attr_type)
        {
            /// 省域id | 标示终端安装车辆所在的省域，0保留，由平台取默认值。省域id采用GB/T 2260中规定的行政区划代码六位中前两位
        case kJtMsg808SessionCompAttrProvinceId:
            result = 0x801;
            break;
    
            /// 市县域id | 标示终端安装车辆所在的市域和县域，0保留，由平台取默认值。市县域id采用GB/T 2260中规定的行政区划代码六位中后四位
        case kJtMsg808SessionCompAttrCityId:
            result = 0x802;
            break;
    
            /// 制造商id | 终端制造商编码,5个字节[2013],11个字节[2019]
        case kJtMsg808SessionCompAttrManufactureId:
            result = GetTestManufactureId((char *)param1, param2);
            break;
    
            /// 终端型号 | 此终端型号由制造商自行定义，位数不足时，后补"0X00"。20个字节[2013]，30个字节[2019]
        case kJtMsg808SessionCompAttrTrmModel:
            result = GetTestTrmModel((char *)param1, param2);
            break;
    
            /// 终端id | 七个字节，由大写字母和数字组成，此终端id由制造商自行定义，位数不足时，后补"0X00"。7个字节[2013]，30个字节[2019]
        case kJtMsg808SessionCompAttrTrmId:
            result = GetTestTrmId((char *)param1, param2);
            break;
    
            /// 车牌颜色 | 车牌颜色，按照JT/T415-2006的5.4.12，未上牌时，取值为0。
        case kJtMsg808SessionCompAttrVehicleColor:
            result = 2;
            break;
    
            /// 公安交通管理部门颁发的机动车号牌
        case kJtMsg808SessionCompAttrVehicleNo:
            result = GetTestVehicleNo((char *)param1, param2);
            break;
    
            /// 车辆VIN码
        case kJtMsg808SessionCompAttrVehicleVin:
            result = GetTestVehicleVin((char *)param1, param2);
            break;
    
            /// 服务器个数
        case kJtMsg808SessionCompAttrServerHostCount:
            result = GetHostCount();
            break;
    
        /// 服务器参数，以冒号分割主机和端口
        case kJtMsg808SessionCompAttrServerHostParam:
            result = GetHostParam(param1, param2);
            break;
    
        /// SIM卡的IMEI号
        case kJtMsg808SessionCompAttrSimImei:
            result = GetTestSimImei((char *)param1, param2);
            break;
    
        /// 终端软件版本号
        case kJtMsg808SessionCompAttrTrmSoftwareVer:
            result = GetTestTrmSoftwareVer((char *)param1, param2);
            break;
        }
    
        return result;
    }
    
    // 消息构造函数信息注册
    static Bool TestJtcMsg808RegisterMsgCreates(void)
    {
        Byte ver = TJtMsg808MgrVer(&g_msg_808_mgr_);
        Bool result = TJtMsg808MgrRegisterOnCreate(&g_msg_808_mgr_, kJtMsg808IdSetParams,
            sizeof(TJtMsg808SetParams), ver, (TJtMsg808DoCreateEvent)TJtMsg808SetParamsCreate);
    
        result = result && TJtMsg808MgrRegisterOnCreate(&g_msg_808_mgr_, kJtMsg808IdGetParam,
            sizeof(TJtMsg808GetParam), ver, (TJtMsg808DoCreateEvent)TJtMsg808GetParamCreate);
    
        result = result && TJtMsg808MgrRegisterOnCreate(&g_msg_808_mgr_, kJtMsg808IdGetParams,
            sizeof(TJtMsg808GetParams), ver, (TJtMsg808DoCreateEvent)TJtMsg808GetParamsCreate);
    
        return result;
    }
    
    // 消息处理函数信息注册
    static Bool TestJtcMsg808RegisterMsgProcs(void)
    {
        Bool result = True;
    //    Byte ver = TJtMsg808MgrVer(&g_msg_808_mgr_);
    
    //    result = result && TJtMsg808MgrRegisterOnMsgProc(&g_msg_808_mgr_, kJtMsg808IdSetParams, ver,
    //        NULL, Jt808ProcParamSetParams);
    
    //    result = result && TJtMsg808MgrRegisterOnMsgProc(&g_msg_808_mgr_, kJtMsg808IdGetParam, ver,
    //        NULL, Jt808ProcParamGetParam);
    
    //    result = result && TJtMsg808MgrRegisterOnMsgProc(&g_msg_808_mgr_, kJtMsg808IdGetParams, ver,
    //        NULL, Jt808ProcParamGetParams);
    
        return result;
    }
    
    // 消息广播
    static void Obos808ChannelOnBroadcase(void *sender, void *receiver, TJtMsg808Head *msg_head)
    {
        TJtMsg808Mgr *self = (TJtMsg808Mgr *)sender;
        
        switch (msg_head->msg_id)
        {
        case kJtMsg808IdSetParams:
            //TJtMsg808SetParamsCreate()
            break;
    
        case kJtMsg808IdGetParam:
    
            break;
    
        case kJtMsg808IdGetParams:
    
            break;
        }
    }
    
    // 初始化
    Bool Obos808ChannelInit(TMfSerialVirBus *serial_vir_bus)
    {
        Bool result = False;
        
        {
            // 创建消息管理器
            TJtMsg808MgrCreate(&g_msg_808_mgr_, kJtMsg808Ver2013);

            // 设置SIM卡号
            TJtMsg808MgrSetSimNo(&g_msg_808_mgr_, "011502089903");

            // 会话组件创建
            TJtMsg808SessionCompCreate(&g_msg_808_session_, &g_msg_808_mgr_, serial_vir_bus, 
                g_session_recv_buf_, sizeof(g_session_recv_buf_), 
                g_session_encode_buf_, sizeof(g_session_encode_buf_), 
                g_session_decode_buf_, sizeof(g_session_decode_buf_));
    
            // 设置属性获取事件
            g_msg_808_session_.OnAttrEvent.Method = TJtMsg808SessionCompAttrEvent;

            // 初始化相关内容
            if (TJtMsg808SessionCompInit(&g_msg_808_session_)
                && TJtMsg808MgrInit(&g_msg_808_mgr_)
                && TestJtcMsg808RegisterMsgCreates()
                && TestJtcMsg808RegisterMsgProcs())
            {
                g_msg_808_mgr_.OnCreateBroadcast.Method = Obos808ChannelOnBroadcase;
                result = True;
            }
        }
        
        return result;
    }
    
    void Obos808ChannelRunOnce(void)
    {
        // 循环调度执行函数
        TJtMsg808SessionCompRunOnce(&g_msg_808_session_);
    }
    
    void Obos808ChannelDone(void)
    {
        // 取初始化
        TJtMsg808SessionCompDone(&g_msg_808_session_);
        OfDestroyObject((TOfObject *)&g_msg_808_session_);
        OfDestroyObject((TOfObject *)&g_msg_808_mgr_);
    }
    
    // 设置数据接收事件
    void Obos808ChannelSetOnRecvEvent(void *recv_object, TJtMsg808SessionCompDoReceiveEvent recv_method)
    {
        g_msg_808_session_.OnRecvEvent.Method = recv_method;
        g_msg_808_session_.OnRecvEvent.object= recv_object;
    }
    
    // 设置数据发送事件
    void Obos808ChannelSetOnSendEvent(void *send_object, TJtMsg808SessionCompDoSendEvent send_method)
    {
        g_msg_808_session_.OnRecvEvent.Method = send_method;
        g_msg_808_session_.OnRecvEvent.object= send_object;
    }
 
 * @endcode
 
 * @{
 * @file         jtc_msg_808_session_comp.h
 * @brief        交通部消息808会话组件
 * @note         
 * @author       Akee
 * @date         2019-11-7
 * @version      1.0
 *
 * @par          修改日志
 * <table>
 * <tr><th>Date        <th>Version               <th>Author          <th>Description
 * <tr><td>2019-11-7   <td>1.0                   <td>Akee            <td>创建初始版本
 * @copyright    杭州鸿泉物联网技术股份有限公司
 */
#ifndef _JTC_MSG_808_SESSION_COMP_H_
#define _JTC_MSG_808_SESSION_COMP_H_
#include "mfc/mfc_serial_vir_bus.h"
#include "jtmsg808/jtc_msg_808_mgr.h"
#include "jtmsg808/jtc_msg_808_2013.h"
#include "jtmsg808/jtc_msg_808_session_interface.h"

#ifdef __cplusplus
extern "C" {
#endif
/**
 * 交通部808会话结果
 */
enum TJtMsg808SessionCompResultEnumTag
{
    kJtMsg808SessionCompResultSuccess   = 0,    ///< 成功
    kJtMsg808SessionCompResultFail      = -1,   ///< 失败
    kJtMsg808SessionCompResultIllegal   = -2,   ///< 不合法(如: 参数不合法)
    kJtMsg808SessionCompResultInvalid   = -3,   ///< 无效
    kJtMsg808SessionCompResultNotExist  = -4,   ///< 不存在
};
typedef enum TJtMsg808SessionCompResultEnumTag TJtMsg808SessionCompResultEnum;


/**
 * 交通部808会话属性枚举
 */
enum TJtMsg808SessionCompAttrEnumTag
{
    /// 省域id | 标示终端安装车辆所在的省域，0保留，由平台取默认值。省域id采用GB/T 2260中规定的行政区划代码六位中前两位
    /// 返回值: Word 类型,省域Id
    kJtMsg808SessionCompAttrProvinceId = 0,

    /// 市县域id | 标示终端安装车辆所在的市域和县域，0保留，由平台取默认值。市县域id采用GB/T 2260中规定的行政区划代码六位中后四位
    /// 返回值: Word 类型,市县域Id
    kJtMsg808SessionCompAttrCityId = 1,
    
    /// 制造商id | 终端制造商编码,5个字节[2013],11个字节[2019]
    /// param1: char *制造商编码，若传NULL,则忽略param2，返回长度
    /// param2: int *制造商编码长度
    /// 返回值: 实际返回制造商编码长度
    kJtMsg808SessionCompAttrManufactureId = 2,

    /// 终端型号 | 此终端型号由制造商自行定义，位数不足时，后补"0X00"。20个字节[2013]，30个字节[2019]
    /// param1: char *终端型号码，若传NULL,则忽略param2，返回长度
    /// param2: int *终端型号长度
    /// 返回值: 实际获取的终端型号长度
    kJtMsg808SessionCompAttrTrmModel = 3,

    /// 终端id | 七个字节，由大写字母和数字组成，此终端id由制造商自行定义，位数不足时，后补"0X00"。7个字节[2013]，30个字节[2019]
    /// param1: char *终端Id，若传NULL,则忽略param2，返回长度
    /// param2: int *终端Id长度
    /// 返回值: 实际获取的终端Id长度
    kJtMsg808SessionCompAttrTrmId = 4,

    /// 车牌颜色 | 车牌颜色，按照JT/T415-2006的5.4.12，未上牌时，取值为0。
    /// 返回值： 车牌颜色
    kJtMsg808SessionCompAttrVehicleColor = 5,

    /// 公安交通管理部门颁发的机动车号牌
    /// param1: char *车牌号，若传NULL,则忽略param2，返回长度
    /// param2: int *车牌号长度
    /// 返回值: 实际获取的车牌号长度
    kJtMsg808SessionCompAttrVehicleNo = 6,

    /// 车辆VIN码
    /// param1: char *终端Id，若传NULL,则忽略param2，返回长度
    /// param2: int *终端Id长度
    /// 返回值: 实际获取的终端Id长度
    kJtMsg808SessionCompAttrVehicleVin = 7,

    /// 服务器个数
    /// 返回值: 终端主备服务器个数
    kJtMsg808SessionCompAttrServerHostCount = 8,

    /// 服务器参数，以冒号分割主机和端口
    /// param1: char *主备服务器，以冒号分割主机和端口,例如www.obos.com:10500
    /// param2: 高2字节: 主备服务器索引号，从0开始; 低2字节: buf长度
    kJtMsg808SessionCompAttrServerHostParam = 9,

    /// SIM卡的IMEI号
    /// param1: char *SIM卡的IMEI，若传NULL,则忽略param2，返回长度
    /// param2: SIM卡的IMEI号长度
    /// 返回值: 实际获取的IMEI长度
    kJtMsg808SessionCompAttrSimImei = 10,

    /// 终端软件版本号
    /// param1: char *终端软件版本号，若传NULL,则忽略param2，返回长度
    /// param2: 软件版本号长度
    /// 返回值: 实际获取的IMEI长度
    kJtMsg808SessionCompAttrTrmSoftwareVer = 11,
};
typedef enum TJtMsg808SessionCompAttrEnumTag TJtMsg808SessionCompAttrEnum;

/**
 * 交通部808会话获取属性事件
 * @param sender: 发起者
 * @param attr_type: 属性类型,参考TJtMsg808SessionCompAttrEnum
 * @param param1: 参数1
 * @param param2: 参数2
 * @return 参考TJtMsg808SessionCompResultEnum; >0: 全部是成功，表示长度; 0表示返回值也是成功，参见具体描述
 */
typedef int(*TJtMsg808SessionCompDoAttrEvent)(void *sender, int attr_type, void *param1, long param2);

/**
 * 交通部808会话属性事件
 * @note 外部提供的此方法需与TJtMsg808SessionCompRunOnce同一个线程
 */
typedef struct TJtMsg808SessionCompOnAttrEventTag TJtMsg808SessionCompOnAttrEvent;
struct TJtMsg808SessionCompOnAttrEventTag
{
    void *object;  ///< 对象指针
    TJtMsg808SessionCompDoAttrEvent Method;  ///< 方法
};

/**
 * 交通部808会话接收数据事件
 * @param sender: 发起者
 * @param buf: 数据缓存
 * @param size: 数据长度
 * @return
 */
typedef void (*TJtMsg808SessionCompDoReceiveEvent)(void *sender, const Byte *buf, Int32 size);

typedef struct TJtMsg808SessionCompOnRecvEventTag TJtMsg808SessionCompOnRecvEvent;
struct TJtMsg808SessionCompOnRecvEventTag
{
    void *object; ///< 对象指针
    TJtMsg808SessionCompDoReceiveEvent  Method;   ///< 方法
};

/**
 * 交通部808会话发送数据事件
 * @param sender: 发起者
 * @param buf: 数据缓存
 * @param size: 数据长度
 * @return
 */
typedef void (*TJtMsg808SessionCompDoSendEvent)(void *sender, const Byte *buf, int size);

typedef struct TJtMsg808SessionCompOnSendEventTag TJtMsg808SessionCompOnSendEvent;
struct TJtMsg808SessionCompOnSendEventTag
{
    void *object; ///< 对象指针
    TJtMsg808SessionCompDoSendEvent  Method;  ///< 方法
};

/**
 * 会话状态
 */
enum TJtMsg808SessionCompStateEnumTag
{
    kJtMsg808SessionCompStateDisconnect     = 0,    ///< 断开连接
    kJtMsg808SessionCompStateConnectOk      = 1,    ///< 连接成功, 带参数host和port
    kJtMsg808SessionCompStateConnectFail    = 2,    ///< 连接失败，带参数host和port
    kJtMsg808SessionCompStateRegistering    = 3,    ///< 注册中
    kJtMsg808SessionCompStateRegisterOk     = 4,    ///< 注册成功
    kJtMsg808SessionCompStateRegisterFail   = 5,    ///< 注册失败
    kJtMsg808SessionCompStateAuthing        = 6,    ///< 鉴权中
    kJtMsg808SessionCompStateAuthOk         = 7,    ///< 鉴权成功
    kJtMsg808SessionCompStateAuthFail       = 8,    ///< 鉴权失败
};
typedef enum TJtMsg808SessionCompStateEnumTag TJtMsg808SessionCompStateEnum;

typedef void(*TJtMsg808SessionCompDoStateNotify)(void *sender, TJtMsg808SessionCompStateEnum state, const void *param, Int32 param_len);

/**
 * 状态通知
 */
typedef struct TJtMsg808SessionCompOnStateNotifyTag TJtMsg808SessionCompOnStateNotify;
struct TJtMsg808SessionCompOnStateNotifyTag
{
    void *object;
    TJtMsg808SessionCompDoStateNotify Method;
};

/**
 * 交通部消息808引擎
 */
typedef struct TJtMsg808SessionCompTag TJtMsg808SessionComp;
struct TJtMsg808SessionCompTag
{
    TOfObject parent_;                      ///< 基类

PROTECTED
    TOfVirtualMethod Destroy_;              ///< 析构事件
    IJtMsg808Session session_;
PUBLIC
    TJtMsg808SessionCompOnAttrEvent OnAttrEvent;        ///< 属性获取事件,Init之前设置好
    TJtMsg808SessionCompOnRecvEvent OnRecvEvent;        ///< 接收消息事件
    TJtMsg808SessionCompOnSendEvent OnSendEvent;        ///< 发送消息事件
    TJtMsg808SessionCompOnStateNotify OnStateNotify;    ///< 状态通知事件
    TJtMsg808Mgr *msg_mgr_;                 ///< 消息管理器

PRIVATE
    TMfSerialVirBus *serial_vir_bus;        ///< 虚拟串行总线对象
    TJtMsg808 *msg_trm_register_;           ///< 注册消息
    TJtMsg808 *msg_trm_auth_;               ///< 鉴权消息

    DWord last_connect_tick_;               ///< 最后一次连接时间,单位: ms
    Int32 connect_intv_;                    ///< 连接间隔,单位:ms

    Int32 recv_size_;                       ///< 接收大小
    Byte *recv_buf_;                        ///< 接收缓冲
    Int32 recv_buf_size_;
    Byte *decode_buf_;                      ///< 解码缓冲
    Int32 decode_buf_size_;                 ///< 解码缓冲
    Byte *encode_buf_;
    Int32 encode_buf_size;
    TMfString connect_ip_;
    UInt16 port_;
    char auth_code_[64];                    ///< 鉴权码
    Byte net_state_;                        ///< 网络状态
    Byte session_state_;                    ///< 会话状态
    Bool timing_send_heartbeat_;            ///< 是否定时发送心跳,默认：True
    Bool param_motify_enable_;              ///< 参数设置使能,默认:True
    Int32 host_index_;
    Int32 heartbeat_time_intv_;             ///< 心跳的时间间隔,单位: 秒
    DWord last_heartbeat_time_;             ///< 最后心跳时间,单位: 秒
    DWord last_recv_server_heartbeat_time_; ///< 最后服务器的心跳时间,单位: 秒

    Int32 recv_timeout_disconn_intv_;       ///< 正常工作(注册/鉴权除外)时多久没有收到服务器的数据,则断开,单位: 秒
    Bool  comm_mode_;                       ///< 串口模式
};

/**
 * 构造函数
 * @param self: 对象指针
 * @param msg_mgr: 消息管理器
 * @param serial_vir_bus: 虚拟总线对象
 * @param recv_buf: 接收缓存
 * @param recv_buf_size: 接收缓存大小，建议传入2100
 * @param temp_buf: 临时缓存
 * @param temp_buf_size: 临时缓存大小
 * @return 
 */
void TJtMsg808SessionCompCreate(TJtMsg808SessionComp *self, TJtMsg808Mgr *msg_mgr, TMfSerialVirBus *serial_vir_bus, 
    Byte *recv_buf, Int32 recv_buf_size, Byte *encode_buf, Int32 encode_buf_size, Byte *decode_buf, Int32 decode_buf_size);

/**
 * 获取消息管理器指针
 * @param self: 对象指针
 * @return 消息管理器指针
 */
TJtMsg808Mgr *TJtMsg808SessionCompMsgMgr(TJtMsg808SessionComp *self);

/**
 * 初始化
 * @param self: 对象指针
 * @return True: 成功; False: 失败
 */
Bool TJtMsg808SessionCompInit(TJtMsg808SessionComp *self);

/**
 * 执行一次函数，需要cpu调度
 * @param self: 对象指针
 * @return 
 */
void TJtMsg808SessionCompRunOnce(TJtMsg808SessionComp *self);

/**
 * 去初始化
 * @param self: 对象指针
 * @return
 */
void TJtMsg808SessionCompDone(TJtMsg808SessionComp *self);

/**
 * 发送消息
 * @param self: 对象指针
 * @param msg: 需要发送的消息,内部不会释放消息
 * @param encode_success: 编码是否成功,若为NULL，则忽略参数,编码失败一般指长度超过1024
 * @return True: 成功; False: 失败
 * @note 发送成功肯定是编码成功，发送失败可能是编码失败或者参数为空
 */
Bool TJtMsg808SessionCompSendMsg(TJtMsg808SessionComp *self, TJtMsg808 *msg, Bool *encode_success);

/**
 * 发送数据
 * @param self: 对象指针
 * @param data: 需要发送的数据
 * @param data_size: 数据大小
 * @return > 0: 实际发送的数据大小; <0: 参数错误; 0: 网络未鉴权成功，也有可能总线底层无缓冲
 * @note 不能保证data_size一次性能全部发出去,内部会判断已经处于鉴权成功状态下才允许发送数据
 */
Int32 TJtMsg808SessionCompSendData(TJtMsg808SessionComp *self, const void *data, Int32 data_size);

/**
 * 设置鉴权码，注意：在构造后进行设置鉴权码
 * @param self: 对象指针
 * @param auth_code: 鉴权码
 * @return 
 * @note 内部最大只保留sizeof(auth_code_) - 1个字节的鉴权码，目前为63个字节
 */
void TJtMsg808SessionCompSetAuthCode(TJtMsg808SessionComp *self, const char *auth_code);

/**
 * 获取鉴权码
 * @param self: 对象指针
 * @return 鉴权码
 */
const char *TJtMsg808SessionCompAuthCode(TJtMsg808SessionComp *self);

/**
 * 目前是否已经鉴权成功，处于在线状态,若在注册过程中，也属于不在线
 * @param self: 对象指针
 * @return True: 在线状态; False: 不在线状态
 * @note : 需要扩展，解决注册过程中的状态开发
 */
Bool TJtMsg808SessionCompIsOnLine(TJtMsg808SessionComp *self);

/**
 * 设置心跳时间间隔
 * @param self: 对象指针
 * @param value: 心跳间隔,单位: 秒
 * @note 内部限制最短时间10秒
 * @return 
 */
void TJtMsg808SessonSetHeartbeatTimeIntv(TJtMsg808SessionComp *self, Int32 value);

/**
 * 获取心跳时间间隔，默认30秒
 * @param self: 对象指针
 * @return 心跳间隔: 单位: 秒
 */
Int32 TJtMsg808SessionCompHeartbeatTimeIntv(TJtMsg808SessionComp *self);

/**
 * 设置多久没有收到数据，断开连接
 * @param self: 对象指针
 * @param value: 断开间隔,单位: 秒
 * @note 内部限制最短时间30秒
 * @return 
 */
void TJtMsg808SessonSetRecvTimeoutDisconnIntv(TJtMsg808SessionComp *self, Int32 value);

/**
 * 获取断开连接时间间隔，默认120秒
 * @param self: 对象指针
 * @return 断开连接时间间隔, 单位: 秒
 */
Int32 TJtMsg808SessionCompRecvTimeoutDisconnIntv(TJtMsg808SessionComp *self);

/**
 * 获取会话状态
 * @param self: 对象指针
 * @return 会话状态
 */
TJtMsg808SessionCompStateEnum TJtMsg808SessionCompState(TJtMsg808SessionComp *self);

/**
 * 获取当前通道的会话参数修改使能,主要针对0x8103参数设置
 * @param self: 对象指针
 * @return True: 可设置; False: 不可设置
 */
Bool TJtMsg808SessionCompParamMotifyEnable(TJtMsg808SessionComp *self);

/**
 * 设置当前通道的会话参数修改使能,主要针对0x8103参数设置
 * @param self: 对象指针
 * @param enable: True: 可设置0x8103; False: 不可设置0x8103
 * @return
 */
void TJtMsg808SessionCompSetParamMotifyEnable(TJtMsg808SessionComp *self, Bool enable);

/**
 * 获取会话接口
 * @param self: 对象指针
 * @return 会话接口
 */
IJtMsg808Session *TJtMsg808SessionCompSession(TJtMsg808SessionComp *self);

/**
 * 设置到串口模式
 * @param self: 对象指针
 * @return
 */
void TJtMsg808SessionCompSetCommMode(TJtMsg808SessionComp *self);

/**
 * 会话开启关闭控制
 * @param self: 对象指针
 * @param enabled: True:开启  False:关闭
 * @return 是否成功
 * @note 关闭后将断开连接
 */
Bool TJtMsg808SessionCompSetEnabled(TJtMsg808SessionComp *self, Bool enabled);

/**
 * 会话开启关闭状态查询
 * @param self: 对象指针
 * @return True:开启  False:关闭
 */
Bool TJtMsg808SessionCompIsEnabled(TJtMsg808SessionComp *self);
#ifdef __cplusplus
} // extern "C" {
#endif
#endif
/**
 * @} 
 */

